JAVA

java异常处理

　　o(╯□╰)o

throwable：一切异常的超类

  • ERROR 错误
  • Exception 异常
    RuntimeException:运行时异常
    其他：编译时异常

try catch

1
2
3
4
5
6
7
8
9
10
11
12
13
package testDemo;

public class test1 {
	public static void main(String[] args) {
		int a=10;
		int b=0;
		try{
			System.out.println(a/0);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}
	}
}

try catch finally

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package testDemo;

public class test1 {
	public static void main(String[] args) {
		int a=10;
		int b=0;
		try{
			System.out.println(a/0);
		}catch(ArithmeticException e){
			e.printStackTrace();
		}finally {
			System.out.println("有异常!");
		}
	}
}

throws

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package testDemo;

class test{
	int a=10;
	int b=0;
	public void show() throws ArithmeticException{
		System.out.println(a/b);
	}
}

public class test1 {
	public static void main(String[] args) {
		try {
			new test().show();
		} catch (ArithmeticException e) {
			e.printStackTrace();
		}
	}
}

throw:要抛出异常的对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package testDemo;

class test{
	int a=10;
	int b=0;
	public void show() throws ArithmeticException{
		if(b==0){
			throw new ArithmeticException();
		}else{
			System.out.println(a/b);
		}
	}
}
public class test1 {
	public static void main(String[] args) {
		try {
			new test().show();
		} catch (ArithmeticException e) {
			e.printStackTrace();
		}
	}
}

throws 和 throw 的区别

  • throws
  • 用在方法声明后面，后面跟异常类名
  • 可以跟多个异常类名，用逗号隔开
  • 表示抛出异常，由该方法的调用者来处理

  • 只表示出现异常的可能性，并不一定会发生异常

  • throw

  • 用在方法体内，跟的是对象名
  • 只能抛出一个异常对象名
  • 表示抛出异常对象

finally

  • 一定会执行
  • 有特殊情况，finally之前有System.exit(0);
  • 用于释放资源，在IO流和数据库操作会见到。

final finally finalize()

  • final: 最终的意思，可以修饰类，成员变量，成员方法
    修饰类，类不能被继承
修饰变量，变量是常量
修饰方法，方法不能被重写
  • finally: 异常处理的一部分，用于释放资源
    一般来说，代码肯定会执行，特殊情况：执行finally之前jvm退出。
  • finalize:Object类的一个方法，用于垃圾回收

如果catch里面有return，finally是否还会执行

会，是在return之前。 但更准确的说是在中间。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package testDemo;

public class test1 {
	public static void main(String[] args) {
		System.out.println(getInt());
	}

	public static int getInt() {
		int a = 10;
		try {
			System.out.println(a / 0);
			a = 20;
		} catch (ArithmeticException e) {
			a = 30;
			return a;
		} finally {
			a = 40;
		}
		return a;
	}
}

结果是输出30，运行调试便知。

如果try里面有return，finally是否还会执行

仍然会，与在catch中类似。(如果try中没有异常发生，就不会走catch)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package testDemo;

public class test1 {
	public static void main(String[] args) {
		System.out.println(getInt());
	}
	public static int getInt() {
		int a = 10;
		try {
			a = 20;
			return a;
		} catch (ArithmeticException e) {
			a = 30;
			return a;
		} finally {
			a = 40;
		}
	}
}

结果输出20。

try catch 集中用法

1
2
3
4
5
A:try...catch...finally
B:try...catch
C:try...catch...catch...
D:try...catch...catch...finally
E:try...finally

自定义异常

　　有时候java中的异常处理不能满足需求，需要自己自定义异常

1
2
3
4
5
6
7
8
public class MyException extends Exception {//必须继承Exception/RuntimeException
	public MyException() {
	}

	public MyException(String message) {
		super(message);//调用父类构造方法即可
	}
}

其他注意事项

  • 子类重写父类方法时，必须抛出相同异常或更具体的异常
  • 父类没有异常，子类不可以抛出异常，只能用try catch 处理

欢迎与我分享你的看法。
转载请注明出处：http://taowusheng.cn/
微博：寒枫–0-0–
知乎：https://www.zhihu.com/people/tao-wu-sheng
豆瓣：YIFEI